<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>

  <body>
    <script>
      // //1. at at() 方法接收一个整数值并返回该索引的项目，允许正数和负数。负整数从数组中的最后一个项目开始倒数。
      // const array = [1, 2, 3, 4];
      // let index = 1;
      // let index2 = -1;
      // console.log(array.at(index)); //1
      // console.log(array.at(index2)); //4

      // //2. every() 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。
      // // 跟some的区别是 some是只要有一个满足就是true every是所有

      // const array2 = [1, 30, 39, 29, 10, 13];
      // console.log(
      //   array2.every((item, index, callback) => {
      //     return item > 40; //false
      //   })
      // );

      // //3.fill() 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。
      // const array3 = [1, 2, 3, 4];

      // // fill with 0 from position 2 until position 4
      // console.log(array3.fill("zks", 2, 3));
      // // expected output: [1, 2, 'zks',4]
      // // fill with 5 from position 1
      // console.log(array3.fill(5, 1));
      // // expected output: [1, 5, 5, 5]
      // console.log(array3.fill(6));
      // // expected output: [6, 6, 6, 6]

      // // 4.find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
      // const array4 = [5, 12, 8, 130, 44];
      // const found = array4.find((element) => element > 10);
      // console.log(found);
      // // expected output: 12

      // //5. findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1。
      // const array5 = [5, 12, 8, 130, 44];
      // const found1 = array5.findIndex((element) => element > 10);
      // console.log(found1);
      // // expected output: 1

      // //6. findLast() 方法返回数组中满足提供的测试函数条件的最后一个元素的值。如果没有找到对应元素，则返回 undefined。
      // const array6 = [5, 12, 8, 13, 4];
      // const found6 = array6.findLast((element) => element > 10);
      // console.log(found6);
      // // expected output: 13

      // //7. findLastIndex() 方法返回数组中满足提供的测试函数条件的最后一个元素的索引。若没有找到对应元素，则返回 -1。
      // const array7 = [5, 12, 8, 13, 4];
      // const found7 = array7.findLastIndex((element) => element > 10);
      // console.log(found7);
      // // expected output: 3

      // //8. flat()将多维数组转为1维数组
      // // 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
      // //     flat(depth)depth 可选
      // // 指定要提取嵌套数组的结构深度，默认值为 1。
      // // flatMap() 方法首先使用映射函数映射每个元素，
      // // 然后将结果压缩成一个新数组。它与 map 连着深度值为 1 的 flat 几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些。
      // const array8 = [0, 1, 2, [3, 4]];

      // console.log(array8.flat(1));
      // // expected output: [0, 1, 2, 3, 4]
      // const array88 = [0, 1, 2, [[[3, 4]]]];
      // console.log(array88.flat(1));
      // // expected output: [0, 1, 2, [3, 4]]

      const city = [
        { name: "a", list: [["徐州", "邳州", "宿羊山"],['南京','栖霞','武当山']] },
        { name: "b", list: [["无锡", "滨湖", "大厦"],['杭州','上城','下城']] }
      ];

      const city2=[
      { name: "a", list: ['南京','栖霞','武当山']},
      { name: "b", list: ["无锡", "滨湖", "大厦"] }
      ]
 
      
      // 原理
        console.log(city.map(item=>{
          return item.list.map(sub=>{
            return sub.flat()
          })
    }).flat().flat());

    console.log(city.flatMap((item,index)=>{
          return item.list.flat()
      }));

    //   console.log(city2.flatMap((item,index)=>{
    //       return item.list
    //   }));
      // //9.Array.from() 方法对一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例
      // console.log(Array.from("foo"));
      // // expected output: Array ["f", "o", "o"]

      // console.log(Array.from([1, 2, 3], (x) => x + x));

      // // 把伪数组转为真数组
      // // expected output: Array [2, 4, 6]

      // const arr = [1, 2, 3];
      // const obj = {
      //   factor: 5,
      // };
      // const newArr = Array.from(
      //   arr,
      //   function (value, index) {
      //     return value * this.factor + index;
      //   },
      //   obj
      // ); //这个this代指obj
      // console.log(newArr); // 输出 [2, 4, 6]

      // // 10.map() 方法创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成

      // const array10 = [1, 4, 9, 16];
      // // pass a function to map
      // const map1 = array10.map((x) => x * 2);

      // console.log(map1);
      // // expected output: Array [2, 8, 18, 32]

      // //11. 数组的累加方法 reduce
      // const array11 = [1, 2, 3, 4];
      // // 0 + 1 + 2 + 3 + 4
      // const initialValue = 0;
      // const sumWithInitial = array11.reduce(
      //   (previousValue, currentValue, currentIndex, array1000) => {
      //     console.log(previousValue, currentValue);
      //     // console.log(currentIndex);
      //     // console.log(array1000); //被遍历的数组
      //     return previousValue + currentValue;
      //   },
      //   initialValue
      // );

      // console.log(sumWithInitial);
      // // expected output: 10
    </script>
  </body>
</html>
